home *** CD-ROM | disk | FTP | other *** search
/ Aminet 35 / Aminet 35 (2000)(Schatztruhe)[!][Feb 2000].iso / Aminet / gfx / misc / gnuplot-src.lha / gnuplot-3.7.1src / gnuplot-3.7.1.lha / gnuplot-3.7.1 / term / tek.trm < prev    next >
Encoding:
Text File  |  1998-12-14  |  18.1 KB  |  760 lines
  1. /*
  2.  * $Id: tph` supports",
  3. "8/12/14 18:41:23 lhecking Exp $
  4.  *
  5.  */
  6.  
  7. /* GNUPLOT - tek.trm */
  8.  
  9. /*[
  10.  * Copyright 1990 - 1993, 1998
  11.  *
  12.  * Permission to use, copy, and distribute this software and its
  13.  * documentation for any purpose with or without fee is hereby granted,
  14.  * provided that the above copyright notice appear in all copies and
  15.  * that both that copyright notice and this permission notice appear
  16.  * in supporting documentation.
  17.  *
  18.  * Permission to modify the software is granted, but not the right to
  19.  * distribute the complete modified source code.  Modifications are to
  20.  * be distributed as patches to the released version.  Permission to
  21.  * distribute binaries produced by compiling modified sources is granted,
  22.  * provided you
  23.  *   1. distribute the corresponding source modifications from the
  24.  *    released version in the form of a patch file along with the binaries,
  25.  *   2. add special version identification to distinguish your version
  26.  *    in addition to the base release version number,
  27.  *   3. provide your name and address as the primary contact for the
  28.  *    support of your modified version, and
  29.  *   4. retain our contact information in regard to use of the base
  30.  *    software.
  31.  * Permission to distribute the released version of the source code along
  32.  * with corresponding source modifications in the form of a patch file is
  33.  * granted with same provisions 2 through 4 for binary distributions.
  34.  *
  35.  * This software is provided "as is" without express or implied warranty
  36.  * to the extent permitted by applicable law.
  37. ]*/
  38.  
  39. /*
  40.  * This file is included by ../term.c.
  41.  *
  42.  * This terminal driver supports:
  43.  *  tek40xx, bitgraph, kermit_color_tek40xx, kermit_mono_tek40xx, selanar
  44.  *  ln03plus
  45.  *
  46.  * AUTHORS
  47.  *   Colin Kelley, Thomas Williams, Russell Lang
  48.  * 
  49.  * send your comments or suggestions to (info-gnuplot@dartmouth.edu).
  50.  * 
  51.  */
  52.  
  53. /*
  54.  * Modified June 1995 Ian MacPhedran to support newterm format
  55.  */
  56. #define TEK
  57. #define CTEK
  58. #define VTTEK
  59. #define KERMIT
  60. #define SELANAR
  61. #define BITGRAPH
  62.  
  63. #include "driver.h"
  64.  
  65. #ifdef TERM_REGISTER
  66. register_term(tek40)
  67. #ifdef VTTEK
  68. register_term(vttek)
  69. #endif
  70. #ifdef KERMIT
  71. register_term(kc_tek40)
  72. register_term(km_tek40)
  73. #endif
  74. #ifdef SELANAR
  75. register_term(selanar)
  76. #endif
  77. #ifdef BITGRAPH
  78. register_term(bitgraph)
  79. #endif
  80. #endif /* TERM_REGISTER */
  81.  
  82. #ifdef TERM_PROTO
  83. TERM_PUBLIC void TEK40init __PROTO((void));
  84. TERM_PUBLIC void TEK40graphics __PROTO((void));
  85. TERM_PUBLIC void TEK40text __PROTO((void));
  86. TERM_PUBLIC void TEK40linetype __PROTO((int linetype));
  87. TERM_PUBLIC void TEK40move __PROTO((unsigned int x, unsigned int y));
  88. TERM_PUBLIC void TEK40vector __PROTO((unsigned int x, unsigned int y));
  89. TERM_PUBLIC void TEK40put_text __PROTO((unsigned int x, unsigned int y, char str[]));
  90. TERM_PUBLIC void TEK40reset __PROTO((void));
  91. TERM_PUBLIC void BG_text __PROTO((void));
  92. TERM_PUBLIC void BG_put_text __PROTO((unsigned int x, unsigned int y, char str[]));
  93. TERM_PUBLIC void KTEK40graphics __PROTO((void));
  94. TERM_PUBLIC void KTEK40Ctext __PROTO((void));
  95. TERM_PUBLIC void KTEK40Clinetype __PROTO((int linetype));
  96. TERM_PUBLIC void KTEK40Mlinetype __PROTO((int linetype));
  97. TERM_PUBLIC void KTEK40reset __PROTO((void));
  98. TERM_PUBLIC void SEL_init __PROTO((void));
  99. TERM_PUBLIC void SEL_graphics __PROTO((void));
  100. TERM_PUBLIC void SEL_text __PROTO((void));
  101. TERM_PUBLIC void SEL_reset __PROTO((void));
  102. TERM_PUBLIC void VTTEK40init __PROTO((void));
  103. TERM_PUBLIC void VTTEK40reset __PROTO((void));
  104. TERM_PUBLIC void VTTEK40linetype __PROTO((int linetype));
  105. TERM_PUBLIC void VTTEK40put_text __PROTO((unsigned int x, unsigned int y, char str[]));
  106. TERM_PUBLIC void CTEK_linetype __PROTO((int linetype));
  107. TERM_PUBLIC void CTEK_move __PROTO((unsigned int x, unsigned int y));
  108. TERM_PUBLIC void CTEK_vector __PROTO((unsigned int x, unsigned int y));
  109.  
  110. #endif /* TERM_PROTO */
  111.  
  112. #ifndef TERM_PROTO_ONLY
  113. #ifdef TERM_BODY
  114.  
  115. #ifdef TEK
  116.  
  117. #define TEK40XMAX 1024
  118. #define TEK40YMAX 780
  119.  
  120. #define TEK40XLAST (TEK40XMAX - 1)
  121. #define TEK40YLAST (TEK40YMAX - 1)
  122.  
  123. #define TEK40VCHAR        25
  124. #define TEK40HCHAR        14
  125. #define TEK40VTIC        11
  126. #define TEK40HTIC        11
  127.  
  128. #define HX 0x20            /* bit pattern to OR over 5-bit data */
  129. #define HY 0x20
  130. #define LX 0x40
  131. #define LY 0x60
  132.  
  133. #define LOWER5 31
  134. #define UPPER5 (31<<5)
  135.  
  136.  
  137. TERM_PUBLIC void TEK40init()
  138. {
  139. }
  140.  
  141.  
  142. TERM_PUBLIC void TEK40graphics()
  143. {
  144. #ifdef VMS
  145.     term_pasthru();
  146. #endif /* VMS */
  147.     fputs("\033\014", gpoutfile);
  148. /*                   1
  149.     1. clear screen
  150. */
  151.     (void) fflush(gpoutfile);
  152.     sleep(1);
  153.     /* sleep 1 second to allow screen time to clear on real 
  154.        tektronix terminals */
  155. }
  156.  
  157. TERM_PUBLIC void TEK40text()
  158. {
  159. #ifdef VMS
  160.     (void) fflush(gpoutfile);    /* finish the graphics */
  161. #endif
  162.     TEK40move(0, 12);
  163.     fputs("\037", gpoutfile);
  164. /*                   1
  165.     1. into alphanumerics
  166. */
  167. #ifdef VMS
  168.     term_nopasthru();
  169. #endif /* VMS */
  170. }
  171.  
  172.  
  173. TERM_PUBLIC void TEK40linetype(linetype)
  174. int linetype;
  175. {
  176. }
  177.  
  178. TERM_PUBLIC void TEK40move(x, y)
  179. unsigned int x, y;
  180. {
  181.     (void) putc('\035', gpoutfile);    /* into graphics */
  182.     TEK40vector(x, y);
  183. }
  184.  
  185.  
  186. TERM_PUBLIC void TEK40vector(x, y)
  187. unsigned int x, y;
  188. {
  189.     (void) putc((HY | (y & UPPER5) >> 5), gpoutfile);
  190.     (void) putc((LY | (y & LOWER5)), gpoutfile);
  191.     (void) putc((HX | (x & UPPER5) >> 5), gpoutfile);
  192.     (void) putc((LX | (x & LOWER5)), gpoutfile);
  193. }
  194.  
  195.  
  196. TERM_PUBLIC void TEK40put_text(x, y, str)
  197. unsigned int x, y;
  198. char str[];
  199. {
  200.     TEK40move(x, y - 11);
  201.     fprintf(gpoutfile, "\037%s\n", str);
  202. }
  203.  
  204.  
  205. TERM_PUBLIC void TEK40reset()
  206. {
  207. }
  208.  
  209. #endif /* TEK */
  210.  
  211.  
  212.  
  213. /* thanks to dukecdu!evs (Ed Simpson) for the BBN BitGraph driver */
  214.  
  215. #ifdef BITGRAPH
  216.  
  217. #define BG_XMAX                 768    /* width of plot area */
  218. #define BG_YMAX                 768    /* height of plot area */
  219. #define BG_SCREEN_HEIGHT    1024    /* full screen height */
  220.  
  221. #define BG_XLAST     (BG_XMAX - 1)
  222. #define BG_YLAST     (BG_YMAX - 1)
  223.  
  224. #define BG_VCHAR    16
  225. #define BG_HCHAR     9
  226. #define BG_VTIC         8
  227. #define BG_HTIC         8
  228.  
  229.  
  230. #define BG_init TEK40init
  231.  
  232. #define BG_graphics TEK40graphics
  233.  
  234.  
  235. #define BG_linetype TEK40linetype
  236.  
  237. #define BG_move TEK40move
  238.  
  239. #define BG_vector TEK40vector
  240.  
  241.  
  242. TERM_PUBLIC void BG_text()
  243. {
  244. #ifdef VMS
  245.     (void) fflush(gpoutfile);    /* finish the graphics */
  246. #endif
  247.     BG_move(0, BG_SCREEN_HEIGHT - 2 * BG_VCHAR);
  248.     fputs("\037", gpoutfile);
  249. /*                   1
  250.     1. into alphanumerics
  251. */
  252. }
  253.  
  254.  
  255. TERM_PUBLIC void BG_put_text(x, y, str)
  256. unsigned int x, y;
  257. char str[];
  258. {
  259.     BG_move(x, y - 11);
  260.     fprintf(gpoutfile, "\037%s\n", str);
  261. }
  262.  
  263.  
  264. #define BG_reset TEK40reset
  265.  
  266. #endif /* BITGRAPH */
  267.  
  268.  
  269. /* Color and Monochrome specials for the MS-DOS Kermit Tektronix Emulator
  270.    by Russell Lang,  eln272v@monu1.cc.monash.oz  */
  271.  
  272. #ifdef KERMIT
  273.  
  274. #define KTEK40HCHAR        13
  275.  
  276. TERM_PUBLIC void KTEK40graphics()
  277. {
  278. #ifdef VMS
  279.     term_mode_tek();
  280.     term_pasthru();
  281. #endif /* VMS */
  282.     fputs("\033\014", gpoutfile);
  283. /*                   1
  284.     1. clear screen
  285. */
  286.     /* kermit tektronix emulation doesn't need to wait */
  287. }
  288.  
  289. TERM_PUBLIC void KTEK40Ctext()
  290. {
  291.     TEK40text();
  292.     KTEK40Clinetype(0);        /* change to green */
  293. #ifdef VMS
  294.     term_nopasthru();
  295. #endif /* VMS */
  296. }
  297.  
  298. /* special color linetypes for MS-DOS Kermit v2.31 tektronix emulator */
  299. /*    0 = normal, 1 = bright 
  300.     foreground color (30-37) = 30 + colors
  301.         where colors are   1=red, 2=green, 4=blue */
  302. static char *kermit_color[15] =
  303. {"\033[0;37m", "\033[1;30m",
  304.  "\033[0;32m", "\033[0;36m", "\033[0;31m", "\033[0;35m",
  305.  "\033[1;34m", "\033[1;33m", "\033[1;31m", "\033[1;37m",
  306.  "\033[1;35m", "\033[1;32m", "\033[1;36m", "\033[0;34m",
  307.  "\033[0;33m"};
  308.  
  309. TERM_PUBLIC void KTEK40Clinetype(linetype)
  310. int linetype;
  311. {
  312.     if (linetype >= 13)
  313.     linetype %= 13;
  314.     fprintf(gpoutfile, "%s", kermit_color[linetype + 2]);
  315. }
  316.  
  317.  
  318. /* linetypes for MS-DOS Kermit v2.30 tektronix emulator */
  319. /* `=solid, a=fine dots, b=short dashes, c=dash dot, 
  320.    d=long dash dot, e=dash dot dot */
  321. static char *kerm_linetype = "`a`abcde";
  322.  
  323. TERM_PUBLIC void KTEK40Mlinetype(linetype)
  324. int linetype;
  325. {
  326.     if (linetype >= 6)
  327.     linetype %= 6;
  328.     fprintf(gpoutfile, "\033%c", kerm_linetype[linetype + 2]);
  329. }
  330.  
  331. TERM_PUBLIC void KTEK40reset()
  332. {
  333.     fputs("\030\n", gpoutfile);    /* turn off Tek emulation */
  334. #ifdef VMS
  335.     term_mode_native();
  336. #endif /* VMS */
  337. }
  338.  
  339. #endif /* KERMIT */
  340.  
  341.  
  342. /* thanks to sask!macphed (Geoff Coleman and Ian Macphedran) for the
  343.    Selanar driver */
  344.  
  345. #ifdef SELANAR
  346.  
  347. TERM_PUBLIC void SEL_init()
  348. {
  349.     fputs("\033\062", gpoutfile);
  350. /*                    1
  351.     1. set to ansi mode
  352. */
  353. }
  354.  
  355.  
  356. TERM_PUBLIC void SEL_graphics()
  357. {
  358.     fputs("\033[H\033[J\033\061\033\014", gpoutfile);
  359. /*                   1           2       3
  360.     1. clear ANSI screen
  361.     2. set to TEK mode
  362.     3. clear screen
  363. */
  364. #ifdef VMS
  365.     term_pasthru();
  366. #endif /* VMS */
  367. }
  368.  
  369.  
  370. TERM_PUBLIC void SEL_text()
  371. {
  372. #ifdef VMS
  373.     (void) fflush(gpoutfile);    /* finish the graphics */
  374. #endif
  375.     TEK40move(0, 12);
  376.     fputs("\033\062", gpoutfile);
  377. /*                   1
  378.     1. into ANSI mode
  379. */
  380. #ifdef VMS
  381.     term_nopasthru();
  382. #endif /* VMS */
  383. }
  384.  
  385. TERM_PUBLIC void SEL_reset()
  386. {
  387.     fputs("\033\061\033\012\033\062\033[H\033[J", gpoutfile);
  388. /*                   1        2       3      4
  389. 1       set tek mode
  390. 2       clear screen
  391. 3       set ansi mode
  392. 4       clear screen
  393. */
  394. }
  395.  
  396. #endif /* SELANAR */
  397.  
  398. #ifdef VTTEK
  399.  
  400. TERM_PUBLIC void VTTEK40init()
  401. {
  402.     fputs("\033[?38h", gpoutfile);
  403.     fflush(gpoutfile);
  404.     sleep(1);
  405.     /* sleep 1 second to allow screen time to clear on some terminals */
  406. #ifdef VMS
  407.     term_mode_tek();
  408. #endif /* VMS */
  409. }
  410.  
  411. TERM_PUBLIC void VTTEK40reset()
  412. {
  413.     fputs("\033[?38l", gpoutfile);
  414.     fflush(gpoutfile);
  415.     sleep(1);
  416.     /* sleep 1 second to allow screen time to clear on some terminals */
  417. #ifdef VMS
  418.     term_mode_native();
  419. #endif /* VMS */
  420. }
  421.  
  422. /* linetypes for VT-type terminals in tektronix emulator mode */
  423. /* `=solid, a=fine dots, b=short dashes, c=dash dot,
  424.    d=long dash dot, h=bold solid, i=bold fine dots, j=bold short dashes,
  425.    k=bold dash dot, l=bold long dash dot */
  426. static char *vt_linetype = "`a`abcdhijkl";
  427. static int last_vt_linetype = 0;
  428. TERM_PUBLIC void VTTEK40linetype(linetype)
  429. int linetype;
  430. {
  431.     if (linetype >= 10)
  432.     linetype %= 10;
  433.     fprintf(gpoutfile, "\033%c", vt_linetype[linetype + 2]);
  434.     last_vt_linetype = linetype;
  435. }
  436.  
  437. TERM_PUBLIC void VTTEK40put_text(x, y, str)
  438. unsigned int x, y;
  439. char str[];
  440. {
  441.     int linetype;
  442.     linetype = last_vt_linetype;
  443.     VTTEK40linetype(0);
  444.     TEK40put_text(x, y, str);
  445.     VTTEK40linetype(linetype);
  446. }
  447.  
  448. #endif /* VTTEK */
  449.  
  450. #ifdef LN03P
  451.  
  452. TERM_PUBLIC void LN03Pinit()
  453. {
  454.     fputs("\033[?38h", gpoutfile);
  455. }
  456.  
  457. TERM_PUBLIC void LN03Preset()
  458. {
  459.     fputs("\033[?38l", gpoutfile);
  460. }
  461.  
  462. #endif /* LN03P */
  463.  
  464.  
  465.  
  466. /* tek40xx (monochrome) with linetype support by Jay I. Choe */
  467. #ifdef CTEK
  468.  
  469. /*#define ABS(A) (((A)>=0)? (A):-(A))*/
  470. #define SIGN(A) (((A) >= 0)? 1:-1)
  471.  
  472. static void CT_solid_vector __PROTO((int x, int y));
  473. static void CT_draw_vpoint __PROTO((int x, int y, int last));
  474. static void CT_pattern_vector __PROTO((int x1, int y1));
  475.  
  476. /* CT_lines are line types defined as bit pattern */
  477. static unsigned long CT_lines[] =
  478. {0xffffffff,            /* solid line */
  479.  0x000fffff,            /* long dash */
  480.  0x00ff00ff,            /* short dash */
  481.  0x00f00fff,            /* dash-dot */
  482.  0x00f07fff,            /* long dash - dot */
  483.  0x07070707,
  484.  0x07ff07ff,
  485.  0x070707ff};
  486.  
  487. /* current line pattern */
  488. static unsigned long *CT_pattern = &CT_lines[0];
  489.  
  490. /* we need to keep track of tek cursor location */
  491. static int CT_last_linetype = 0, CT_last_x, CT_last_y;
  492.  
  493. TERM_PUBLIC void CTEK_linetype(linetype)
  494. int linetype;
  495. {
  496.     if (linetype < 0)
  497.     linetype = 0;
  498.     linetype %= (sizeof(CT_lines) / sizeof(unsigned long));
  499.     CT_pattern = &CT_lines[linetype];
  500.     CT_last_linetype = linetype;
  501. }
  502.  
  503. TERM_PUBLIC void CTEK_move(x, y)
  504. unsigned int x;
  505. unsigned int y;
  506. {
  507.     TEK40move(x, y);
  508.     CT_last_x = x;
  509.     CT_last_y = y;
  510. }
  511.  
  512. static void CT_solid_vector(x, y)
  513. int x;
  514. int y;
  515. {
  516.     TEK40vector(x, y);
  517.     CT_last_x = x;
  518.     CT_last_y = y;
  519. }
  520.  
  521. /*
  522.    simulate pixel draw using tek vector draw.
  523.    delays actual line drawing until maximum line segment is determined
  524.    (or first/last point is defined)
  525. */
  526. static int CT_penon = 0;    /* is Pen on? */
  527.  
  528. static void CT_draw_vpoint(x, y, last)
  529. int x;
  530. int y;
  531. int last;
  532. {
  533.     static int xx0, yy0, xx1, yy1;
  534.  
  535.     if ((*CT_pattern) & 1) {
  536.     if (CT_penon) {        /* This point is a continuation of current line */
  537.         xx1 = x;
  538.         yy1 = y;
  539.     } else {        /* beginning of new line */
  540.         xx0 = xx1 = x;
  541.         yy0 = yy1 = y;
  542.         CT_penon = 1;
  543.     }
  544.     *CT_pattern = ((*CT_pattern) >> 1) | 0x80000000;    /* rotate the pattern */
  545.     if (last) {        /* draw the line anyway if this is the last point */
  546.         TEK40move(xx0, yy0);
  547.         TEK40vector(xx1, yy1);
  548.         CT_penon = 0;
  549.     }
  550.     } else {            /* do not draw this pixel */
  551.     if (CT_penon) {        /* last line segment ended at the previous pixel. */
  552.         /* draw the line */
  553.         TEK40move(xx0, yy0);
  554.         TEK40vector(xx1, yy1);
  555.         CT_penon = 0;
  556.     }
  557.     *CT_pattern = (*CT_pattern) >> 1;    /* rotate the current pattern */
  558.     }
  559. }
  560.  
  561. /*
  562.    draw vector line with pattern
  563. */
  564.  
  565. static void CT_pattern_vector(x1, y1)
  566. int x1;
  567. int y1;
  568. {
  569.     int op;            /* order parameter */
  570.     int x0 = CT_last_x;
  571.     int y0 = CT_last_y;
  572.     int dx = x1 - x0;
  573.     int dy = y1 - y0;
  574.     int ax = ABS(dx) << 1;
  575.     int ay = ABS(dy) << 1;
  576.     int sx = SIGN(dx);
  577.     int sy = SIGN(dy);
  578.  
  579.     if (ax >= ay) {
  580.     for (op = ay - (ax >> 1); x0 != x1; x0 += sx, op += ay) {
  581.         CT_draw_vpoint(x0, y0, 0);
  582.         if (op > 0 || (op == 0 && sx == 1)) {
  583.         op -= ax;
  584.         y0 += sy;
  585.         }
  586.     }
  587.     } else {            /* ax < ay */
  588.     for (op = ax - (ay >> 1); y0 != y1; y0 += sy, op += ax) {
  589.         CT_draw_vpoint(x0, y0, 0);
  590.         if (op > 0 || (op == 0 && sy == 1)) {
  591.         op -= ay;
  592.         x0 += sx;
  593.         }
  594.     }
  595.     }
  596.     CT_draw_vpoint(x0, y0, 1);    /* last point */
  597.     CT_last_x = x1;
  598.     CT_last_y = y1;
  599. }
  600.  
  601. TERM_PUBLIC void CTEK_vector(x, y)
  602. unsigned int x;
  603. unsigned int y;
  604. {
  605.     if (CT_last_linetype <= 0)
  606.     CT_solid_vector(x, y);
  607.     else
  608.     CT_pattern_vector(x, y);
  609. }
  610.  
  611. #endif /* CTEK */
  612. #endif /* TERM_BODY */
  613.  
  614. #ifdef TERM_TABLE
  615.  
  616. TERM_TABLE_START(tek40_driver)
  617. #ifndef CTEK
  618.     "tek40xx", "Tektronix 4010 and others; most TEK emulators",
  619.     TEK40XMAX, TEK40YMAX, TEK40VCHAR, TEK40HCHAR,
  620.     TEK40VTIC, TEK40HTIC, options_null, TEK40init, TEK40reset,
  621.     TEK40text, null_scale, TEK40graphics, TEK40move, TEK40vector,
  622.     TEK40linetype, TEK40put_text, null_text_angle,
  623.     null_justify_text, line_and_point, do_arrow, set_font_null
  624. #else
  625.     "tek40xx", "Tektronix 4010 and others; most TEK emulators",
  626.     TEK40XMAX, TEK40YMAX, TEK40VCHAR, TEK40HCHAR,
  627.     TEK40VTIC, TEK40HTIC, options_null, TEK40init, TEK40reset,
  628.     TEK40text, null_scale, TEK40graphics, CTEK_move, CTEK_vector,
  629.     CTEK_linetype, TEK40put_text, null_text_angle,
  630.     null_justify_text, line_and_point, do_arrow, set_font_null
  631. #endif /* CTEK */
  632. TERM_TABLE_END(tek40_driver)
  633.  
  634. #undef LAST_TERM
  635. #define LAST_TERM tek40_driver
  636.  
  637. #ifdef VTTEK
  638. TERM_TABLE_START(vttek_driver)
  639.     "vttek", "VT-like tek40xx terminal emulator",
  640.     TEK40XMAX, TEK40YMAX, TEK40VCHAR, TEK40HCHAR,
  641.     TEK40VTIC, TEK40HTIC, options_null, VTTEK40init, VTTEK40reset,
  642.     TEK40text, null_scale, TEK40graphics, TEK40move, TEK40vector,
  643.     VTTEK40linetype, VTTEK40put_text, null_text_angle,
  644.     null_justify_text, line_and_point, do_arrow, set_font_null
  645. TERM_TABLE_END(vttek_driver)
  646.  
  647. #undef LAST_TERM
  648. #define LAST_TERM vttek_driver
  649.  
  650. #endif /* VTTEK */
  651.  
  652. #ifdef KERMIT
  653. TERM_TABLE_START(kc_tek40_driver)
  654.    "kc_tek40xx", "MS-DOS Kermit Tek4010 terminal emulator - color",
  655.     TEK40XMAX, TEK40YMAX, TEK40VCHAR, KTEK40HCHAR,
  656.     TEK40VTIC, TEK40HTIC, options_null, TEK40init, KTEK40reset,
  657.     KTEK40Ctext, null_scale, KTEK40graphics, TEK40move, TEK40vector,
  658.     KTEK40Clinetype, TEK40put_text, null_text_angle,
  659.     null_justify_text, do_point, do_arrow, set_font_null
  660. TERM_TABLE_END(kc_tek40_driver)
  661.  
  662. #undef LAST_TERM
  663. #define LAST_TERM kc_tek40_driver
  664.  
  665. TERM_TABLE_START(km_tek40_driver)
  666.     "km_tek40xx", "MS-DOS Kermit Tek4010 terminal emulator - monochrome",
  667.     TEK40XMAX, TEK40YMAX, TEK40VCHAR, KTEK40HCHAR,
  668.     TEK40VTIC, TEK40HTIC, options_null, TEK40init, KTEK40reset,
  669.     TEK40text, null_scale, KTEK40graphics, TEK40move, TEK40vector,
  670.     KTEK40Mlinetype, TEK40put_text, null_text_angle,
  671.     null_justify_text, line_and_point, do_arrow, set_font_null
  672. TERM_TABLE_END(km_tek40_driver)
  673.  
  674. #undef LAST_TERM
  675. #define LAST_TERM km_tek40_driver
  676.  
  677. #endif /* KERMIT */
  678.  
  679. #ifdef SELANAR
  680. TERM_TABLE_START(selanar_driver)
  681.     "selanar", "Selanar",
  682.     TEK40XMAX, TEK40YMAX, TEK40VCHAR, TEK40HCHAR,
  683.     TEK40VTIC, TEK40HTIC, options_null, SEL_init, SEL_reset,
  684.     SEL_text, null_scale, SEL_graphics, TEK40move, TEK40vector,
  685.     TEK40linetype, TEK40put_text, null_text_angle,
  686.     null_justify_text, line_and_point, do_arrow, set_font_null
  687. TERM_TABLE_END(selanar_driver)
  688.  
  689. #undef LAST_TERM
  690. #define LAST_TERM selanar_driver
  691.  
  692. #endif /* SELANAR */
  693.  
  694. #ifdef BITGRAPH
  695. TERM_TABLE_START(bitgraph_driver)
  696.     "bitgraph", "BBN Bitgraph Terminal",
  697.     BG_XMAX, BG_YMAX, BG_VCHAR, BG_HCHAR,
  698.     BG_VTIC, BG_HTIC, options_null, BG_init, BG_reset,
  699.     BG_text, null_scale, BG_graphics, BG_move, BG_vector,
  700.     BG_linetype, BG_put_text, null_text_angle,
  701.     null_justify_text, line_and_point, do_arrow, set_font_null
  702. TERM_TABLE_END(bitgraph_driver)
  703.  
  704. #undef LAST_TERM
  705. #define LAST_TERM bitgraph_driver
  706.  
  707. #endif /* BITGRAPH */
  708.  
  709. #endif /* TERM_TABLE */
  710.  
  711. #endif /* TERM_PROTO_ONLY */
  712.  
  713. #ifdef TERM_HELP
  714. START_HELP(tek40)
  715. "1 tek40",
  716. "?commands set terminal tek40xx",
  717. "?set terminal tek40xx",
  718. "?set term tek40xx",
  719. "?terminal tek40xx",
  720. "?terminal tek40xx",
  721. "?tek40",
  722. "?commands set terminal vttek",
  723. "?set terminal vttek",
  724. "?set term vttek",
  725. "?terminal vttek",
  726. "?term vttek",
  727. "?vttek",
  728. "?commands set terminal kc-tek40xx",
  729. "?set terminal kc-tek40xx",
  730. "?set term kc-tek40xx",
  731. "?terminal kc-tek40xx",
  732. "?term kc-tek40xx",
  733. "?kc-tek40xx",
  734. "?commands set terminal km-tek40xx",
  735. "?set terminal km-tek40xx",
  736. "?set term km-tek40xx",
  737. "?terminal km-tek40xx",
  738. "?term km-tek40xx",
  739. "?km-tek40xx",
  740. "?commands set terminal selanar",
  741. "?set terminal selanar",
  742. "?set term selanar",
  743. "?terminal selanar",
  744. "?term selanar",
  745. "?selanar",
  746. "?commands set terminal bitgraph",
  747. "?set terminal bitgraph",
  748. "?set term bitgraph",
  749. "?terminal bitgraph",
  750. "?term bitgraph",
  751. "?bitgraph",
  752. " This family of terminal drivers supports a variety of VT-like terminals.",
  753. " `tek40xx` supports Tektronix 4010 and others as well as most TEK emulators;",
  754. " `vttek` supports VT-like tek40xx terminal emulators; `kc-tek40xx` supports",
  755. " MS-DOS Kermit Tek4010 terminal emulators in color: `km-tek40xx` supports them",
  756. " in monochrome; `selanar` supports Selanar graphics; and `bitgraph` supports",
  757. " BBN Bitgraph terminals.  None have any options."
  758. END_HELP(tek40)
  759. #endif /* TERM_HELP */
  760.